Hibernate Criteria API হল Hibernate ফ্রেমওয়ার্কের একটি শক্তিশালী বৈশিষ্ট্য যা object-oriented উপায়ে ডেটাবেস কুয়েরি তৈরি করতে সাহায্য করে। Criteria API-এর সাহায্যে আপনি ডেটাবেস থেকে ডেটা রিট্রিভ করতে পারেন, এবং এটি SQL কুয়েরির মতো জটিলতা ছাড়াই ডাইনামিক কুয়েরি তৈরি করার অনুমতি দেয়।
Criteria API মূলত Type-safe, dynamic, এবং object-oriented কুয়েরি তৈরি করার জন্য ব্যবহৃত হয়, যা জেনেরিক টাইপ ব্যবহার করে আপনাকে কুয়েরি তৈরি করতে দেয়।
Hibernate 5.0 এর পর Criteria API কে JPA Criteria API হিসেবে স্থাপন করা হয়েছে। তবে Hibernate এখনও নিজস্ব Criteria API সমর্থন করে, যা পুরনো কোডবেসের জন্য দরকারী।
এটি hibernate.cfg.xml ফাইলে সাধারণ কনফিগারেশন সেটিংস অন্তর্ভুক্ত করে:
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/yourdb</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">password</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
</session-factory>
</hibernate-configuration>
ধরা যাক আমাদের একটি Employee ক্লাস রয়েছে, যেখানে id, name, এবং salary নামক প্রোপার্টি রয়েছে।
@Entity
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private double salary;
// Getters, Setters, and Constructors
}
এখন আমরা Hibernate Criteria API ব্যবহার করে Employee টেবিল থেকে সমস্ত Employee রেকর্ড রিট্রিভ করব।
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.CriteriaQuery;
import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
// Step 1: Create SessionFactory
SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
// Step 2: Create session
Session session = factory.getCurrentSession();
try {
// Step 3: Start transaction
session.beginTransaction();
// Step 4: Create Criteria object
CriteriaQuery<Employee> criteriaQuery = session.createCriteria(Employee.class);
// Step 5: Get the list of employees
List<Employee> employees = criteriaQuery.list();
// Step 6: Display the employees
for (Employee employee : employees) {
System.out.println(employee);
}
// Step 7: Commit the transaction
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Restrictions ব্যবহার করে আপনি ডেটাবেসের সাথে শর্তযুক্ত কুয়েরি তৈরি করতে পারেন। এতে eq(), like(), gt(), lt(), ne() ইত্যাদি পদ্ধতি ব্যবহার করা হয়।
ধরা যাক আমরা Employee টেবিল থেকে এমন সকল কর্মচারী নির্বাচন করতে চাই যাদের salary 50000 এর বেশি।
import org.hibernate.criterion.Restrictions;
Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.gt("salary", 50000));
List<Employee> employees = criteria.list();
এখানে, Restrictions.gt() ব্যবহার করে আমরা salary > 50000 শর্ত যোগ করেছি।
Projections ব্যবহার করে আপনি নির্দিষ্ট কলাম নির্বাচন করতে পারেন বা aggregate functions (যেমন: COUNT, SUM, AVG) ব্যবহার করতে পারেন।
ধরা যাক আমরা Employee টেবিল থেকে সমস্ত salary এর যোগফল এবং গড় বের করতে চাই।
import org.hibernate.criterion.Projections;
Criteria criteria = session.createCriteria(Employee.class);
criteria.setProjection(Projections.sum("salary"));
Double totalSalary = (Double) criteria.uniqueResult();
criteria.setProjection(Projections.avg("salary"));
Double avgSalary = (Double) criteria.uniqueResult();
System.out.println("Total Salary: " + totalSalary);
System.out.println("Average Salary: " + avgSalary);
এখানে Projections.sum() এবং Projections.avg() ব্যবহার করা হয়েছে টোটাল এবং গড় স্যালারি বের করতে।
Ordering ব্যবহার করে আপনি কুয়েরির রিটার্ন হওয়া ফলাফল সাজাতে পারেন। এটি ascending বা descending অর্ডারে সাজানোর জন্য ব্যবহৃত হয়।
import org.hibernate.criterion.Order;
Criteria criteria = session.createCriteria(Employee.class);
criteria.addOrder(Order.asc("salary"));
List<Employee> employees = criteria.list();
for (Employee employee : employees) {
System.out.println(employee);
}
এখানে, Order.asc("salary") ব্যবহার করা হয়েছে যাতে স্যালারি ascending অর্ডারে সাজানো হয়।
Hibernate Criteria API ব্যবহার করে আরও জটিল কুয়েরি তৈরি করতে পারেন, যেমন একাধিক শর্ত যোগ করা এবং আগের শর্তের উপর ভিত্তি করে AND/OR সম্পর্কিত শর্ত যোগ করা।
Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.ge("salary", 50000)); // salary >= 50000
criteria.add(Restrictions.like("name", "John%")); // name starts with "John"
criteria.addOrder(Order.desc("salary")); // order by salary descending
List<Employee> employees = criteria.list();
for (Employee employee : employees) {
System.out.println(employee);
}
এখানে, Restrictions.ge(), Restrictions.like(), এবং Order.desc() ব্যবহার করে কমপ্লেক্স কুয়েরি তৈরি করা হয়েছে।
Hibernate Criteria API হল একটি শক্তিশালী টুল যা type-safe, dynamic, এবং object-oriented কুয়েরি তৈরি করতে সাহায্য করে। এটি আপনাকে SQL এর জটিলতা ছাড়াই ডেটাবেসের সাথে ইন্টারঅ্যাক্ট করার সুযোগ দেয় এবং HQL বা SQL এর তুলনায় আরও কার্যকরভাবে কুয়েরি তৈরি করতে সহায়ক। Hibernate Criteria API ব্যবহার করে আপনি filters, aggregations, ordering, এবং dynamic queries তৈরি করতে পারেন, যা ডেটাবেস অপারেশনকে সহজ, পারফরম্যান্ট এবং রক্ষণাবেক্ষণযোগ্য করে তোলে।
Hibernate Criteria API হল Hibernate এর একটি API যা আপনাকে SQL কুয়েরি লেখার পরিবর্তে Java কোড দিয়ে ডেটাবেস কুয়েরি তৈরি করতে সক্ষম করে। এটি object-oriented উপায়ে কুয়েরি তৈরি করার জন্য একটি শক্তিশালী এবং টাইপ-সেফ পদ্ধতি প্রদান করে, যা আপনাকে কোডের মধ্যে ডাইনামিক এবং লজিক্যাল কুয়েরি তৈরি করতে সহায়তা করে।
Hibernate Criteria API, Hibernate Query Language (HQL) এবং JPA Criteria API এর একটি বিকল্প হিসেবে কাজ করে। এটি সাধারণত complex, dynamic, এবং প্যারামিটারাইজড কুয়েরি তৈরি করতে ব্যবহৃত হয়, যেখানে traditional SQL বা HQL কোডের পরিবর্তে Java objects ব্যবহার করা হয়।
Hibernate Criteria API হল একটি object-oriented API যা Java objects, properties এবং conditions ব্যবহার করে ডেটাবেসের সাথে সম্পর্কিত কুয়েরি তৈরি করতে সহায়তা করে। Criteria API, Session.createCriteria() মেথডের মাধ্যমে ব্যবহার করা হয়, যা আপনাকে কুয়েরি তৈরি এবং execution এ সাহায্য করে।
Criteria API কোড লেখার সময় dynamic query generation, strong typing, এবং compile-time checking প্রদান করে, যা traditional string-based query execution এর তুলনায় অনেক সুবিধাজনক।
ধরা যাক, আমাদের একটি Employee টেবিল আছে এবং আমরা Criteria API ব্যবহার করে ডেটাবেস থেকে Employee অবজেক্টের উপর নির্দিষ্ট শর্তে কুয়েরি চালাতে চাই।
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
public class CriteriaExample {
public static void main(String[] args) {
// Hibernate configuration and session factory setup
SessionFactory factory = new Configuration()
.configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
// Create a session
Session session = factory.getCurrentSession();
try {
// Start a transaction
session.beginTransaction();
// Create Criteria object to query Employee class
Criteria criteria = session.createCriteria(Employee.class);
// Adding condition (where salary > 50000)
criteria.add(Restrictions.gt("salary", 50000));
// Execute the query and get the result list
List<Employee> employees = criteria.list();
// Display the results
for (Employee employee : employees) {
System.out.println(employee);
}
// Commit the transaction
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
কী ঘটছে?
session.createCriteria(Employee.class) দ্বারা Employee ক্লাসের জন্য একটি Criteria object তৈরি করা হয়েছে।criteria.add(Restrictions.gt("salary", 50000)) দিয়ে salary > 50000 শর্ত যুক্ত করা হয়েছে।criteria.list() মেথড ব্যবহার করে কুয়েরি এক্সিকিউট করা হয়েছে এবং সেই অনুযায়ী সমস্ত Employee রেকর্ড বের করা হয়েছে।Criteria API দিয়ে আপনি একাধিক শর্ত (conditions) যোগ করতে পারেন, যেমন AND বা OR শর্ত।
import org.hibernate.criterion.Restrictions;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = new Configuration()
.configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create Criteria object
Criteria criteria = session.createCriteria(Employee.class);
// Adding multiple conditions with AND operator
criteria.add(Restrictions.and(
Restrictions.eq("department", "Sales"),
Restrictions.gt("salary", 50000)
));
List<Employee> employees = criteria.list();
for (Employee employee : employees) {
System.out.println(employee);
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
এখানে, AND condition ব্যবহার করা হয়েছে, যেখানে department = "Sales" এবং salary > 50000 দুটি শর্ত একসাথে পূর্ণ হতে হবে।
Criteria API ব্যবহার করে আপনি aggregate functions যেমন count(), avg(), max(), min() ইত্যাদি ব্যবহার করতে পারেন।
import org.hibernate.criterion.Projections;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = new Configuration()
.configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create Criteria object
Criteria criteria = session.createCriteria(Employee.class);
// Add projection (aggregate function)
criteria.setProjection(Projections.avg("salary"));
List<Double> avgSalary = criteria.list();
System.out.println("Average Salary: " + avgSalary.get(0));
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
এখানে, Projections.avg("salary") ব্যবহার করে সমস্ত Employee এর গড় বেতন হিসাব করা হয়েছে।
Hibernate Criteria API একটি শক্তিশালী, object-oriented উপায় যা ডেটাবেস কুয়েরি তৈরি এবং এক্সিকিউট করার জন্য ব্যবহৃত হয়। এটি SQL কোডের পরিবর্তে Java objects ব্যবহার করে কুয়েরি তৈরি করতে সাহায্য করে এবং এতে type safety, dynamic query generation, এবং SQL injection থেকে সুরক্ষা প্রদান করে। Criteria API-এর মাধ্যমে আপনি complex এবং dynamic কুয়েরি তৈরি করতে পারেন যা SQL বা HQL লেখার তুলনায় আরও সহজ এবং নিরাপদ।
Hibernate Criteria API হল একটি শক্তিশালী উপায় যা Hibernate ORM ব্যবহার করে ডাইনামিক এবং টাইপ-সেফ কুয়েরি তৈরি করার জন্য ব্যবহৃত হয়। Criteria API এর মাধ্যমে, আপনি SQL এর মতো কোড না লিখে, Java কোডের মাধ্যমে ডাটাবেস কুয়েরি তৈরি করতে পারেন, যা কোডের জন্য আরও নিরাপদ এবং উন্নত।
Hibernate-এ Criteria API ব্যবহার করার জন্য কিছু নির্দিষ্ট স্টেপ অনুসরণ করতে হয়। এই API আপনাকে Query By Example, Dynamic Queries, এবং Type-Safe Queries তৈরি করতে সহায়তা করে। এটি ডেটাবেস কুয়েরি তৈরির জন্য Session অবজেক্টের একটি অংশ হিসেবে কাজ করে।
প্রথমে, Hibernate কনফিগারেশন ফাইল (hibernate.cfg.xml) তৈরি করুন বা সেটআপ করুন যেখানে ডাটাবেস কনফিগারেশন ও Hibernate সেটিংস থাকবে।
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
<property name="hibernate.connection.driver_class">org.h2.Driver</property>
<property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
<property name="hibernate.connection.username">sa</property>
<property name="hibernate.connection.password"></property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
</session-factory>
</hibernate-configuration>
এটি Hibernate কনফিগারেশন ফাইল যা ডাটাবেসের সাথে সংযোগ তৈরি করে এবং Hibernate এর অন্যান্য প্রপার্টি কনফিগার করে।
এখন Hibernate Entity ক্লাস তৈরি করুন। এখানে আমরা একটি সাধারণ Employee ক্লাস তৈরি করব।
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Employee {
@Id
private int id;
private String name;
private String department;
// Constructor, Getter and Setter methods
public Employee() {}
public Employee(int id, String name, String department) {
this.id = id;
this.name = name;
this.department = department;
}
// Getters and Setters
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
}
এখানে, Employee ক্লাসটি একটি জাভা অবজেক্ট যা JPA Entity হিসেবে ডাটাবেস টেবিলের সাথে ম্যাপ হবে।
Hibernate Criteria API ব্যবহার করে ডাইনামিক কুয়েরি তৈরি করার জন্য, প্রথমে Session অবজেক্ট থেকে Criteria অবজেক্ট তৈরি করতে হয়। তারপর Restrictions ব্যবহার করে কুয়েরি নির্দিষ্ট করা হয়।
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class EmployeeDAO {
private SessionFactory sessionFactory;
public EmployeeDAO(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public List<Employee> getEmployeesByDepartment(String department) {
// Session তৈরি করা
Session session = sessionFactory.getCurrentSession();
// Criteria API ব্যবহার করে কুয়েরি তৈরি করা
Criteria criteria = session.createCriteria(Employee.class);
criteria.add(Restrictions.eq("department", department));
// কুয়েরি চলানো এবং ফলাফল পাওয়া
List<Employee> employees = criteria.list();
return employees;
}
}
এখানে:
createCriteria(Employee.class): এটি Employee Entity ক্লাসের জন্য একটি Criteria অবজেক্ট তৈরি করে।Restrictions.eq("department", department): এটি department ফিল্ডের মানকে department প্যারামিটার দিয়ে ফিল্টার করে।এখন MainApp ক্লাস ব্যবহার করে Criteria API কুয়েরি চালানো হবে এবং Employee ডাটাবেস থেকে ফিল্টার করা হবে।
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import java.util.List;
public class MainApp {
public static void main(String[] args) {
// SessionFactory তৈরি করা
SessionFactory sessionFactory = new Configuration().configure().addAnnotatedClass(Employee.class).buildSessionFactory();
// EmployeeDAO ক্লাস ইনস্ট্যান্স তৈরি করা
EmployeeDAO employeeDAO = new EmployeeDAO(sessionFactory);
// Department এর উপর ভিত্তি করে Employees সংগ্রহ করা
List<Employee> employees = employeeDAO.getEmployeesByDepartment("IT");
// Employees এর তথ্য প্রিন্ট করা
for (Employee employee : employees) {
System.out.println("ID: " + employee.getId() + ", Name: " + employee.getName() + ", Department: " + employee.getDepartment());
}
// SessionFactory বন্ধ করা
sessionFactory.close();
}
}
এখানে:
getEmployeesByDepartment("IT") মেথডের মাধ্যমে "IT" ডিপার্টমেন্টের সমস্ত Employee অবজেক্ট ফিল্টার করা হচ্ছে।Employee অবজেক্টের তথ্য কনসোলে প্রিন্ট করা হচ্ছে।যদি আপনার ডাটাবেসে "IT" ডিপার্টমেন্টের কোনো Employee অবজেক্ট থাকে, তাহলে কনসোলে এমন কিছু আউটপুট দেখাবে:
ID: 1, Name: John Doe, Department: IT
ID: 2, Name: Jane Doe, Department: IT
Hibernate Criteria API আরও অনেক শক্তিশালী ফিচার প্রদান করে যেমন:
Restrictions: বিভিন্ন ধরনের কন্ডিশনাল ফিল্টার (যেমন eq, gt, lt, like, in, ইত্যাদি) অ্যাপ্লাই করতে ব্যবহার করা হয়।Projection: ফলাফল থেকে নির্দিষ্ট ফিল্ড বা কলাম নির্বাচন করতে ব্যবহার করা হয় (যেমন select SQL এ)।
criteria.setProjection(Projections.property("name"));
Order: ফলাফলগুলি সাজানোর জন্য।
criteria.addOrder(Order.asc("name"));
Pagination: ডাটাবেসে একসাথে রেকর্ডের পরিমাণ সীমিত করার জন্য (যেমন LIMIT SQL এ)।
criteria.setFirstResult(0);
criteria.setMaxResults(10);
Hibernate Criteria API একটি শক্তিশালী পদ্ধতি যা আপনাকে ডাইনামিক এবং টাইপ-সেফ কুয়েরি তৈরি করতে সহায়তা করে। এটি SQL স্টেটমেন্ট লেখার পরিবর্তে Java কোডের মাধ্যমে ডাটাবেস কুয়েরি তৈরি করার জন্য একটি পরিষ্কার এবং মডুলার পদ্ধতি প্রদান করে। Criteria API দিয়ে আপনি সহজেই ডেটা ফিল্টারিং, অর্ডারিং, এবং পেজিনেশন করতে পারবেন, যা আপনার ডাটাবেস অপারেশনকে আরও কার্যকরী এবং মডুলার করে তোলে।
Restrictions এবং Projections Hibernate এর দুটি শক্তিশালী ফিচার, যা Criteria API ব্যবহার করে queries তৈরি করতে সহায়ক। এগুলি ডেটা রিট্রিভ করার প্রক্রিয়া আরও ফ্লেক্সিবল এবং কার্যকরী করতে ব্যবহৃত হয়, বিশেষ করে যখন আপনাকে complex filtering বা specific fields চয়ন করতে হয়।
এই অংশে Restrictions এবং Projections কীভাবে কাজ করে এবং তাদের ব্যবহার কীভাবে ডেটা রিট্রিভাল অপটিমাইজ করতে সাহায্য করে তা আলোচনা করা হবে।
Restrictions Hibernate Criteria API-তে queries কাস্টমাইজ করার জন্য ব্যবহৃত হয়। এটি filtering এবং conditional expressions এর মাধ্যমে ডেটা সংগ্রহের জন্য অত্যন্ত কার্যকর। Restrictions ব্যবহার করে আপনি where conditions, like, between, equals, ইত্যাদি বিভিন্ন ধরনের শর্ত ব্যবহার করতে পারেন।
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class RetrieveExample {
public static void main(String[] args) {
// Step 1: Create session factory and session
SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
// Step 2: Begin transaction
session.beginTransaction();
// Step 3: Use Criteria to apply Restrictions (filter employees with salary greater than 50000)
List<Employee> employees = session.createCriteria(Employee.class)
.add(Restrictions.gt("salary", 50000))
.list();
// Step 4: Display the results
for (Employee emp : employees) {
System.out.println(emp);
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Restrictions.gt("salary", 50000): এই restriction salary ফিল্ডের জন্য একটি শর্ত তৈরি করে যা 50000 এর চেয়ে বড় মান রিটার্ন করবে।createCriteria(Employee.class): এটি Employee ক্লাসের উপর একটি Criteria query তৈরি করে।Projections Hibernate Criteria API-তে ব্যবহার করা হয়, যখন আপনি specific fields (columns) বা aggregated results (যেমন COUNT, SUM) রিটার্ন করতে চান। Projection মূলত SQL-এর SELECT কুয়েরি অংশের মতো কাজ করে, যার মাধ্যমে আপনি কোন ফিল্ড বা ডেটা রিটার্ন করবেন তা নিয়ন্ত্রণ করতে পারেন।
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Projections;
import java.util.List;
public class RetrieveExample {
public static void main(String[] args) {
// Step 1: Create session factory and session
SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
// Step 2: Begin transaction
session.beginTransaction();
// Step 3: Using Projections to retrieve only "name" and "salary" columns
List<Object[]> results = session.createCriteria(Employee.class)
.setProjection(Projections.projectionList()
.add(Projections.property("name"))
.add(Projections.property("salary")))
.list();
// Step 4: Display the results
for (Object[] result : results) {
System.out.println("Employee Name: " + result[0] + ", Salary: " + result[1]);
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Projections.property("name"): এটি শুধুমাত্র name ফিল্ডটি রিটার্ন করার জন্য ব্যবহৃত হয়।Projections.property("salary"): এটি salary ফিল্ডের মান রিটার্ন করে।setProjection(Projections.projectionList()): এটি একাধিক ফিল্ড নির্বাচন করার জন্য ব্যবহৃত হয়।Projections শুধুমাত্র একক ফিল্ড বা ডেটা রিটার্ন করতে নয়, বরং aggregation functions (যেমন COUNT, SUM, AVG, MIN, MAX) হিসাব করতে সাহায্য করে।
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Projections;
public class RetrieveExample {
public static void main(String[] args) {
// Step 1: Create session factory and session
SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
// Step 2: Begin transaction
session.beginTransaction();
// Step 3: Use Projections to calculate the total salary of all employees
Double totalSalary = (Double) session.createCriteria(Employee.class)
.setProjection(Projections.sum("salary"))
.uniqueResult();
System.out.println("Total Salary: " + totalSalary);
// Step 4: Use Projections to count the number of employees
Long employeeCount = (Long) session.createCriteria(Employee.class)
.setProjection(Projections.rowCount())
.uniqueResult();
System.out.println("Total Employees: " + employeeCount);
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Projections.sum("salary"): এটি সমস্ত salary ফিল্ডের মোট যোগফল রিটার্ন করবে।Projections.rowCount(): এটি টেবিলের মোট রেকর্ড (কাউন্ট) রিটার্ন করবে।Hibernate Criteria API-তে Restrictions এবং Projections একসাথে ব্যবহার করা সম্ভব, যেখানে আপনি একদিকে শর্ত আরোপ (filtering) করবেন এবং অন্যদিকে নির্দিষ্ট ফিল্ড বা অ্যাগ্রিগেটেড ভ্যালু রিটার্ন করবেন।
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
public class RetrieveExample {
public static void main(String[] args) {
// Step 1: Create session factory and session
SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
.addAnnotatedClass(Employee.class)
.buildSessionFactory();
Session session = factory.getCurrentSession();
try {
// Step 2: Begin transaction
session.beginTransaction();
// Step 3: Use Restrictions and Projections together
List<Object[]> results = session.createCriteria(Employee.class)
.add(Restrictions.gt("salary", 30000))
.setProjection(Projections.projectionList()
.add(Projections.property("name"))
.add(Projections.property("salary")))
.list();
// Step 4: Display the results
for (Object[] result : results) {
System.out.println("Employee Name: " + result[0] + ", Salary: " + result[1]);
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Restrictions.gt("salary", 30000): এখানে salary এর মান ৩০,০০০ এর চেয়ে বড় হওয়া উচিত।Projections.property("name") এবং Projections.property("salary"): এখানে name এবং salary রিটার্ন করা হচ্ছে যেগুলি salary > 30000 শর্তে ফিল্টার করা হয়েছে।Hibernate Criteria API-তে Restrictions এবং Projections ব্যবহারের মাধ্যমে আপনি ডেটা ফিল্টার এবং কাস্টমাইজ করতে পারেন। এই দুই ফিচারের মাধ্যমে:
like, equal, greaterThan, ইত্যাদি)।COUNT, SUM, AVG) রিটার্ন করতে সাহায্য করে।এই দুটি ফিচারের সঠিক ব্যবহার আপনার কোডকে আরও কার্যকরী, নমনীয় এবং পারফরম্যান্স অপটিমাইজড করতে সাহায্য করবে।
Hibernate Criteria API হল একটি শক্তিশালী উপায় যার মাধ্যমে ডাইনামিক কুয়েরি তৈরি করা যায়। এটি Hibernate ORM ফ্রেমওয়ার্কে Object-Oriented কোড লিখে SQL কুয়েরি তৈরি করতে সহায়তা করে। Criteria API আপনাকে Type-safe, dynamic queries, এবং complex queries তৈরির সুবিধা প্রদান করে, যেখানে আপনি JPA-এর CriteriaBuilder এবং CriteriaQuery ব্যবহার করে কোডের মাধ্যমে কুয়েরি তৈরি করতে পারেন।
Criteria API হাইবারনেট 3.x-এ তৈরি হয়েছিল এবং এটি JPA (Java Persistence API) স্পেসিফিকেশনের অংশ হিসেবে JPA Criteria API হিসেবে উন্নত করা হয়েছে। Hibernate Criteria API মূলত ডাইনামিক কুয়েরি তৈরি করতে ব্যবহৃত হয়, যেখানে আপনার কুয়েরি প্রোগ্রাম্যাটিকভাবে তৈরি করা হয় এবং type-safe থাকে।
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Student {
@Id
private int id;
private String name;
private String course;
// Getters and Setters
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
}
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
In this example, the Criteria object retrieves all students from the Student table. The query is simple and fetches all records.
You can use Restrictions to add conditions to your query (similar to WHERE in SQL).
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Apply restriction to filter students by course
criteria.add(Restrictions.eq("course", "Java")); // Similar to WHERE course='Java'
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
In this example:
Restrictions.eq() is used to filter students whose course is "Java".You can combine multiple restrictions (conditions) using Restrictions.and() or Restrictions.or().
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Apply multiple restrictions (AND condition)
criteria.add(Restrictions.eq("course", "Java"));
criteria.add(Restrictions.like("name", "John%")); // Name starts with John
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
In this example:
Restrictions.like() is used to filter students whose names start with "John".You can easily sort the results using Order.
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Sort the students by name in ascending order
criteria.addOrder(Order.asc("name"));
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
In this example:
Order.asc("name") sorts the results by student name in ascending order.You can also paginate results using setFirstResult() and setMaxResults().
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Set pagination parameters (page 1 with 5 records per page)
criteria.setFirstResult(0);
criteria.setMaxResults(5);
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
In this example:
setFirstResult(0): This sets the first record to fetch (start at the first record).setMaxResults(5): This limits the number of records to 5.You can dynamically build queries based on conditions, allowing for flexible and reusable code.
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import java.util.List;
public class CriteriaExample {
public static void main(String[] args) {
SessionFactory factory = HibernateUtil.getSessionFactory();
Session session = factory.getCurrentSession();
try {
session.beginTransaction();
// Create a Criteria instance
Criteria criteria = session.createCriteria(Student.class);
// Dynamically add restrictions
String course = "Java"; // Can be dynamically set
if (course != null && !course.isEmpty()) {
criteria.add(Restrictions.eq("course", course));
}
// Execute the query and get the list of students
List<Student> students = criteria.list();
for (Student student : students) {
System.out.println(student.getName() + ": " + student.getCourse());
}
session.getTransaction().commit();
} finally {
factory.close();
}
}
}
Here, the query is dynamically adjusted based on the condition, which makes it flexible for use in various scenarios.
Hibernate Criteria API একটি শক্তিশালী এবং type-safe উপায়, যা dynamic queries তৈরি করতে সাহায্য করে। এর মাধ্যমে আপনি complex queries তৈরি করতে পারেন এবং filters, sorting, pagination সহ বিভিন্ন কার্যক্রম পরিচালনা করতে পারেন। Criteria API ব্যবহার করলে SQL-এর মতো কুয়েরি লিখতে হয় না, এবং কোড লিখতে অনেক বেশি সুবিধা হয় কারণ এটি type-safe এবং compile-time checking প্রদান করে।
Read more
or
